home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Freeware / Miro 1.0 / Miro_Installer.exe / Miro_Downloader.exe / BitTorrent / RawServer.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2007-11-12  |  18.8 KB  |  832 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. from bisect import insort
  5. import socket
  6. from cStringIO import StringIO
  7. from traceback import print_exc
  8. from errno import EWOULDBLOCK, ENOBUFS
  9.  
  10. try:
  11.     from select import poll, error, POLLIN, POLLOUT, POLLERR, POLLHUP
  12.     timemult = 1000
  13. except ImportError:
  14.     from selectpoll import poll, error, POLLIN, POLLOUT, POLLERR, POLLHUP
  15.     timemult = 1
  16.  
  17. from threading import Thread, Event
  18. from time import time, sleep
  19. import sys
  20. from random import randrange
  21. all = POLLIN | POLLOUT
  22.  
  23. try:
  24.     socketpair = socket.socketpair
  25. except AttributeError:
  26.     
  27.     def socketpair():
  28.         dummy_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  29.         dummy_server.bind(('127.0.0.1', 0))
  30.         dummy_server.listen(1)
  31.         server_address = dummy_server.getsockname()
  32.         first = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  33.         first.connect(server_address)
  34.         (second, address) = dummy_server.accept()
  35.         dummy_server.close()
  36.         return (first, second)
  37.  
  38.  
  39.  
  40. class SingleSocket:
  41.     
  42.     def __init__(self, raw_server, sock, handler):
  43.         self.raw_server = raw_server
  44.         self.socket = sock
  45.         self.handler = handler
  46.         self.buffer = []
  47.         self.last_hit = time()
  48.         self.fileno = sock.fileno()
  49.         self.connected = False
  50.  
  51.     
  52.     def get_ip(self):
  53.         
  54.         try:
  55.             return self.socket.getpeername()[0]
  56.         except socket.error:
  57.             return 'no connection'
  58.  
  59.  
  60.     
  61.     def close(self):
  62.         sock = self.socket
  63.         self.socket = None
  64.         self.buffer = []
  65.         del self.raw_server.single_sockets[self.fileno]
  66.         self.raw_server.poll.unregister(sock)
  67.         sock.close()
  68.  
  69.     
  70.     def shutdown(self, val):
  71.         self.socket.shutdown(val)
  72.  
  73.     
  74.     def is_flushed(self):
  75.         return len(self.buffer) == 0
  76.  
  77.     
  78.     def write(self, s):
  79.         if not self.socket is not None:
  80.             raise AssertionError
  81.         self.buffer.append(s)
  82.         if len(self.buffer) == 1:
  83.             self.try_write()
  84.         
  85.  
  86.     
  87.     def try_write(self):
  88.         if self.connected:
  89.             
  90.             try:
  91.                 while self.buffer != []:
  92.                     amount = self.socket.send(self.buffer[0])
  93.                     if amount != len(self.buffer[0]):
  94.                         if amount != 0:
  95.                             self.buffer[0] = self.buffer[0][amount:]
  96.                         
  97.                         break
  98.                     
  99.                     del self.buffer[0]
  100.             except socket.error:
  101.                 e = None
  102.                 (code, msg) = e
  103.                 if code != EWOULDBLOCK:
  104.                     self.raw_server.dead_from_write.append(self)
  105.                     return None
  106.                 
  107.             except:
  108.                 code != EWOULDBLOCK
  109.             
  110.  
  111.         None<EXCEPTION MATCH>socket.error
  112.         if self.buffer == []:
  113.             self.raw_server.poll.register(self.socket, POLLIN)
  114.         else:
  115.             self.raw_server.poll.register(self.socket, all)
  116.  
  117.  
  118.  
  119. def default_error_handler(x):
  120.     print x
  121.  
  122.  
  123. class RawServer:
  124.     
  125.     def __init__(self, doneflag, timeout_check_interval, timeout, noisy = True, errorfunc = default_error_handler, maxconnects = 55):
  126.         self.timeout_check_interval = timeout_check_interval
  127.         self.timeout = timeout
  128.         self.poll = poll()
  129.         self.single_sockets = { }
  130.         self.dead_from_write = []
  131.         self.doneflag = doneflag
  132.         self.noisy = noisy
  133.         self.errorfunc = errorfunc
  134.         self.maxconnects = maxconnects
  135.         self.funcs = []
  136.         self.unscheduled_tasks = []
  137.         self.add_task(self.scan_for_timeouts, timeout_check_interval)
  138.         (self.wakeup_receiver, self.wakeup_sender) = socketpair()
  139.         self.poll.register(self.wakeup_receiver, POLLIN)
  140.  
  141.     
  142.     def wakeup(self):
  143.         self.wakeup_sender.send('a')
  144.  
  145.     
  146.     def add_task(self, func, delay):
  147.         self.unscheduled_tasks.append((func, delay))
  148.  
  149.     
  150.     def scan_for_timeouts(self):
  151.         self.add_task(self.scan_for_timeouts, self.timeout_check_interval)
  152.         t = time() - self.timeout
  153.         tokill = []
  154.         for s in self.single_sockets.values():
  155.             if s.last_hit < t:
  156.                 tokill.append(s)
  157.                 continue
  158.         
  159.         for k in tokill:
  160.             if k.socket is not None:
  161.                 self._close_socket(k)
  162.                 continue
  163.         
  164.  
  165.     
  166.     def bind(self, port, bind = '', reuse = False):
  167.         self.bindaddr = bind
  168.         server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  169.         if reuse:
  170.             server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
  171.         
  172.         server.setblocking(0)
  173.         
  174.         try:
  175.             server.setsockopt(socket.IPPROTO_IP, socket.IP_TOS, 32)
  176.         except:
  177.             pass
  178.  
  179.         server.bind((bind, port))
  180.         server.listen(5)
  181.         self.poll.register(server, POLLIN)
  182.         self.server = server
  183.  
  184.     
  185.     def start_connection(self, dns, handler = None):
  186.         if handler is None:
  187.             handler = self.handler
  188.         
  189.         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  190.         sock.setblocking(0)
  191.         
  192.         try:
  193.             sock.setsockopt(socket.IPPROTO_IP, socket.IP_TOS, 32)
  194.         except:
  195.             pass
  196.  
  197.         sock.bind((self.bindaddr, 0))
  198.         
  199.         try:
  200.             sock.connect_ex(dns)
  201.         except socket.error:
  202.             raise 
  203.         except Exception:
  204.             e = None
  205.             raise socket.error(str(e))
  206.  
  207.         self.poll.register(sock, POLLIN)
  208.         s = SingleSocket(self, sock, handler)
  209.         self.single_sockets[sock.fileno()] = s
  210.         return s
  211.  
  212.     
  213.     def handle_events(self, events):
  214.         for sock, event in events:
  215.             if sock == self.wakeup_receiver.fileno():
  216.                 self.wakeup_receiver.recv(1024)
  217.                 continue
  218.             
  219.             if sock == self.server.fileno():
  220.                 pass
  221.             None if event & (POLLHUP | POLLERR) != 0 else None<EXCEPTION MATCH>socket.error
  222.             s = self.single_sockets.get(sock)
  223.             if s is None:
  224.                 continue
  225.             
  226.             s.connected = True
  227.             if event & (POLLHUP | POLLERR) != 0:
  228.                 self._close_socket(s)
  229.                 continue
  230.             
  231.             if event & POLLIN != 0:
  232.                 
  233.                 try:
  234.                     s.last_hit = time()
  235.                     data = s.socket.recv(100000)
  236.                     if data == '':
  237.                         self._close_socket(s)
  238.                     else:
  239.                         s.handler.data_came_in(s, data)
  240.                 except socket.error:
  241.                     e = None
  242.                     (code, msg) = e
  243.                     if code != EWOULDBLOCK:
  244.                         self._close_socket(s)
  245.                         continue
  246.                     
  247.                 except:
  248.                     code != EWOULDBLOCK
  249.                 
  250.  
  251.             None<EXCEPTION MATCH>socket.error
  252.             if event & POLLOUT != 0 and s.socket is not None and not s.is_flushed():
  253.                 s.try_write()
  254.                 if s.is_flushed():
  255.                     s.handler.connection_flushed(s)
  256.                 
  257.             s.is_flushed()
  258.         
  259.  
  260.     
  261.     def pop_unscheduled(self):
  262.         
  263.         try:
  264.             while True:
  265.                 (func, delay) = self.unscheduled_tasks.pop()
  266.                 insort(self.funcs, (time() + delay, func))
  267.         except IndexError:
  268.             pass
  269.  
  270.  
  271.     
  272.     def listen_forever(self, handler):
  273.         self.handler = handler
  274.         
  275.         try:
  276.             while not self.doneflag.isSet():
  277.                 
  278.                 try:
  279.                     self.pop_unscheduled()
  280.                     if len(self.funcs) == 0:
  281.                         period = 1073741824
  282.                     else:
  283.                         period = self.funcs[0][0] - time()
  284.                     if period < 0:
  285.                         period = 0
  286.                     
  287.                     events = self.poll.poll(period * timemult)
  288.                     if self.doneflag.isSet():
  289.                         return None
  290.                     
  291.                     while len(self.funcs) > 0 and self.funcs[0][0] <= time():
  292.                         (garbage, func) = self.funcs[0]
  293.                         del self.funcs[0]
  294.                         
  295.                         try:
  296.                             func()
  297.                         continue
  298.                         except KeyboardInterrupt:
  299.                             print_exc()
  300.                             return None
  301.                             continue
  302.                             if self.noisy:
  303.                                 data = StringIO()
  304.                                 print_exc(file = data)
  305.                                 self.errorfunc(data.getvalue())
  306.                             
  307.                         
  308.  
  309.                         None<EXCEPTION MATCH>KeyboardInterrupt
  310.                     self._close_dead()
  311.                     self.handle_events(events)
  312.                     if self.doneflag.isSet():
  313.                         return None
  314.                     
  315.                     self._close_dead()
  316.                 continue
  317.                 except error:
  318.                     e = None
  319.                     if self.doneflag.isSet():
  320.                         return None
  321.                     
  322.                     
  323.                     try:
  324.                         (code, msg, desc) = e
  325.                     except:
  326.                         
  327.                         try:
  328.                             (code, msg) = e
  329.                         code = ENOBUFS
  330.  
  331.  
  332.                     if code == ENOBUFS:
  333.                         self.errorfunc('Have to exit due to the TCP stack flaking out')
  334.                         return None
  335.                     
  336.                     code == ENOBUFS
  337.                     except KeyboardInterrupt:
  338.                         print_exc()
  339.                         return None
  340.                         continue
  341.                         data = StringIO()
  342.                         print_exc(file = data)
  343.                         self.errorfunc(data.getvalue())
  344.                         continue
  345.                     
  346.                     None<EXCEPTION MATCH>KeyboardInterrupt
  347.                 for ss in self.single_sockets.values():
  348.                     ss.close()
  349.                 
  350.  
  351.             self.server.close()
  352.             return None
  353.  
  354.  
  355.     
  356.     def _close_dead(self):
  357.         while len(self.dead_from_write) > 0:
  358.             old = self.dead_from_write
  359.             self.dead_from_write = []
  360.             for s in old:
  361.                 if s.socket is not None:
  362.                     self._close_socket(s)
  363.                     continue
  364.             
  365.  
  366.     
  367.     def _close_socket(self, s):
  368.         sock = s.socket.fileno()
  369.         s.socket.close()
  370.         self.poll.unregister(sock)
  371.         del self.single_sockets[sock]
  372.         s.socket = None
  373.         s.handler.connection_lost(s)
  374.  
  375.  
  376.  
  377. class DummyHandler:
  378.     
  379.     def __init__(self):
  380.         self.external_made = []
  381.         self.data_in = []
  382.         self.lost = []
  383.  
  384.     
  385.     def external_connection_made(self, s):
  386.         self.external_made.append(s)
  387.  
  388.     
  389.     def data_came_in(self, s, data):
  390.         self.data_in.append((s, data))
  391.  
  392.     
  393.     def connection_lost(self, s):
  394.         self.lost.append(s)
  395.  
  396.     
  397.     def connection_flushed(self, s):
  398.         pass
  399.  
  400.  
  401.  
  402. def sl(rs, handler, port):
  403.     rs.bind(port)
  404.     Thread(target = rs.listen_forever, args = [
  405.         handler]).start()
  406.  
  407.  
  408. def loop(rs):
  409.     x = []
  410.     
  411.     def r(rs = rs, x = x):
  412.         rs.add_task(x[0], 0.1)
  413.  
  414.     x.append(r)
  415.     rs.add_task(r, 0.1)
  416.  
  417. beginport = 5000 + randrange(10000)
  418.  
  419. def test_starting_side_close():
  420.     
  421.     try:
  422.         fa = Event()
  423.         fb = Event()
  424.         da = DummyHandler()
  425.         sa = RawServer(fa, 100, 100)
  426.         loop(sa)
  427.         sl(sa, da, beginport)
  428.         db = DummyHandler()
  429.         sb = RawServer(fb, 100, 100)
  430.         loop(sb)
  431.         sl(sb, db, beginport + 1)
  432.         sleep(0.5)
  433.         ca = sa.start_connection(('127.0.0.1', beginport + 1))
  434.         sleep(1)
  435.         if not da.external_made == []:
  436.             raise AssertionError
  437.         if not da.data_in == []:
  438.             raise AssertionError
  439.         if not da.lost == []:
  440.             raise AssertionError
  441.         if not len(db.external_made) == 1:
  442.             raise AssertionError
  443.         cb = db.external_made[0]
  444.         del db.external_made[:]
  445.         if not db.data_in == []:
  446.             raise AssertionError
  447.         if not db.lost == []:
  448.             raise AssertionError
  449.         ca.write('aaa')
  450.         cb.write('bbb')
  451.         sleep(1)
  452.         if not da.external_made == []:
  453.             raise AssertionError
  454.         if not da.data_in == [
  455.             (ca, 'bbb')]:
  456.             raise AssertionError
  457.         del da.data_in[:]
  458.         if not da.lost == []:
  459.             raise AssertionError
  460.         if not db.external_made == []:
  461.             raise AssertionError
  462.         if not db.data_in == [
  463.             (cb, 'aaa')]:
  464.             raise AssertionError
  465.         del db.data_in[:]
  466.         if not db.lost == []:
  467.             raise AssertionError
  468.         ca.write('ccc')
  469.         cb.write('ddd')
  470.         sleep(1)
  471.         if not da.external_made == []:
  472.             raise AssertionError
  473.         if not da.data_in == [
  474.             (ca, 'ddd')]:
  475.             raise AssertionError
  476.         del da.data_in[:]
  477.         if not da.lost == []:
  478.             raise AssertionError
  479.         if not db.external_made == []:
  480.             raise AssertionError
  481.         if not db.data_in == [
  482.             (cb, 'ccc')]:
  483.             raise AssertionError
  484.         del db.data_in[:]
  485.         if not db.lost == []:
  486.             raise AssertionError
  487.         ca.close()
  488.         sleep(1)
  489.         if not da.external_made == []:
  490.             raise AssertionError
  491.         if not da.data_in == []:
  492.             raise AssertionError
  493.         if not da.lost == []:
  494.             raise AssertionError
  495.         if not db.external_made == []:
  496.             raise AssertionError
  497.         if not db.data_in == []:
  498.             raise AssertionError
  499.         if not db.lost == [
  500.             cb]:
  501.             raise AssertionError
  502.         del db.lost[:]
  503.     finally:
  504.         fa.set()
  505.         fb.set()
  506.  
  507.  
  508.  
  509. def test_receiving_side_close():
  510.     
  511.     try:
  512.         da = DummyHandler()
  513.         fa = Event()
  514.         sa = RawServer(fa, 100, 100)
  515.         loop(sa)
  516.         sl(sa, da, beginport + 2)
  517.         db = DummyHandler()
  518.         fb = Event()
  519.         sb = RawServer(fb, 100, 100)
  520.         loop(sb)
  521.         sl(sb, db, beginport + 3)
  522.         sleep(0.5)
  523.         ca = sa.start_connection(('127.0.0.1', beginport + 3))
  524.         sleep(1)
  525.         if not da.external_made == []:
  526.             raise AssertionError
  527.         if not da.data_in == []:
  528.             raise AssertionError
  529.         if not da.lost == []:
  530.             raise AssertionError
  531.         if not len(db.external_made) == 1:
  532.             raise AssertionError
  533.         cb = db.external_made[0]
  534.         del db.external_made[:]
  535.         if not db.data_in == []:
  536.             raise AssertionError
  537.         if not db.lost == []:
  538.             raise AssertionError
  539.         ca.write('aaa')
  540.         cb.write('bbb')
  541.         sleep(1)
  542.         if not da.external_made == []:
  543.             raise AssertionError
  544.         if not da.data_in == [
  545.             (ca, 'bbb')]:
  546.             raise AssertionError
  547.         del da.data_in[:]
  548.         if not da.lost == []:
  549.             raise AssertionError
  550.         if not db.external_made == []:
  551.             raise AssertionError
  552.         if not db.data_in == [
  553.             (cb, 'aaa')]:
  554.             raise AssertionError
  555.         del db.data_in[:]
  556.         if not db.lost == []:
  557.             raise AssertionError
  558.         ca.write('ccc')
  559.         cb.write('ddd')
  560.         sleep(1)
  561.         if not da.external_made == []:
  562.             raise AssertionError
  563.         if not da.data_in == [
  564.             (ca, 'ddd')]:
  565.             raise AssertionError
  566.         del da.data_in[:]
  567.         if not da.lost == []:
  568.             raise AssertionError
  569.         if not db.external_made == []:
  570.             raise AssertionError
  571.         if not db.data_in == [
  572.             (cb, 'ccc')]:
  573.             raise AssertionError
  574.         del db.data_in[:]
  575.         if not db.lost == []:
  576.             raise AssertionError
  577.         cb.close()
  578.         sleep(1)
  579.         if not da.external_made == []:
  580.             raise AssertionError
  581.         if not da.data_in == []:
  582.             raise AssertionError
  583.         if not da.lost == [
  584.             ca]:
  585.             raise AssertionError
  586.         del da.lost[:]
  587.         if not db.external_made == []:
  588.             raise AssertionError
  589.         if not db.data_in == []:
  590.             raise AssertionError
  591.         if not db.lost == []:
  592.             raise AssertionError
  593.     finally:
  594.         fa.set()
  595.         fb.set()
  596.  
  597.  
  598.  
  599. def test_connection_refused():
  600.     
  601.     try:
  602.         da = DummyHandler()
  603.         fa = Event()
  604.         sa = RawServer(fa, 100, 100)
  605.         loop(sa)
  606.         sl(sa, da, beginport + 6)
  607.         sleep(0.5)
  608.         ca = sa.start_connection(('127.0.0.1', beginport + 15))
  609.         sleep(1)
  610.         if not da.external_made == []:
  611.             raise AssertionError
  612.         if not da.data_in == []:
  613.             raise AssertionError
  614.         if not da.lost == [
  615.             ca]:
  616.             raise AssertionError
  617.         del da.lost[:]
  618.     finally:
  619.         fa.set()
  620.  
  621.  
  622.  
  623. def test_both_close():
  624.     
  625.     try:
  626.         da = DummyHandler()
  627.         fa = Event()
  628.         sa = RawServer(fa, 100, 100)
  629.         loop(sa)
  630.         sl(sa, da, beginport + 4)
  631.         sleep(1)
  632.         db = DummyHandler()
  633.         fb = Event()
  634.         sb = RawServer(fb, 100, 100)
  635.         loop(sb)
  636.         sl(sb, db, beginport + 5)
  637.         sleep(0.5)
  638.         ca = sa.start_connection(('127.0.0.1', beginport + 5))
  639.         sleep(1)
  640.         if not da.external_made == []:
  641.             raise AssertionError
  642.         if not da.data_in == []:
  643.             raise AssertionError
  644.         if not da.lost == []:
  645.             raise AssertionError
  646.         if not len(db.external_made) == 1:
  647.             raise AssertionError
  648.         cb = db.external_made[0]
  649.         del db.external_made[:]
  650.         if not db.data_in == []:
  651.             raise AssertionError
  652.         if not db.lost == []:
  653.             raise AssertionError
  654.         ca.write('aaa')
  655.         cb.write('bbb')
  656.         sleep(1)
  657.         if not da.external_made == []:
  658.             raise AssertionError
  659.         if not da.data_in == [
  660.             (ca, 'bbb')]:
  661.             raise AssertionError
  662.         del da.data_in[:]
  663.         if not da.lost == []:
  664.             raise AssertionError
  665.         if not db.external_made == []:
  666.             raise AssertionError
  667.         if not db.data_in == [
  668.             (cb, 'aaa')]:
  669.             raise AssertionError
  670.         del db.data_in[:]
  671.         if not db.lost == []:
  672.             raise AssertionError
  673.         ca.write('ccc')
  674.         cb.write('ddd')
  675.         sleep(1)
  676.         if not da.external_made == []:
  677.             raise AssertionError
  678.         if not da.data_in == [
  679.             (ca, 'ddd')]:
  680.             raise AssertionError
  681.         del da.data_in[:]
  682.         if not da.lost == []:
  683.             raise AssertionError
  684.         if not db.external_made == []:
  685.             raise AssertionError
  686.         if not db.data_in == [
  687.             (cb, 'ccc')]:
  688.             raise AssertionError
  689.         del db.data_in[:]
  690.         if not db.lost == []:
  691.             raise AssertionError
  692.         ca.close()
  693.         cb.close()
  694.         sleep(1)
  695.         if not da.external_made == []:
  696.             raise AssertionError
  697.         if not da.data_in == []:
  698.             raise AssertionError
  699.         if not da.lost == []:
  700.             raise AssertionError
  701.         if not db.external_made == []:
  702.             raise AssertionError
  703.         if not db.data_in == []:
  704.             raise AssertionError
  705.         if not db.lost == []:
  706.             raise AssertionError
  707.     finally:
  708.         fa.set()
  709.         fb.set()
  710.  
  711.  
  712.  
  713. def test_normal():
  714.     l = []
  715.     f = Event()
  716.     s = RawServer(f, 100, 100)
  717.     loop(s)
  718.     sl(s, DummyHandler(), beginport + 7)
  719.     s.add_task((lambda l = l: l.append('b')), 2)
  720.     s.add_task((lambda l = l: l.append('a')), 1)
  721.     s.add_task((lambda l = l: l.append('d')), 4)
  722.     sleep(1.5)
  723.     s.add_task((lambda l = l: l.append('c')), 1.5)
  724.     sleep(3)
  725.     if not l == [
  726.         'a',
  727.         'b',
  728.         'c',
  729.         'd']:
  730.         raise AssertionError
  731.     f.set()
  732.  
  733.  
  734. def test_catch_exception():
  735.     l = []
  736.     f = Event()
  737.     s = RawServer(f, 100, 100, False)
  738.     loop(s)
  739.     sl(s, DummyHandler(), beginport + 9)
  740.     s.add_task((lambda l = l: l.append('b')), 2)
  741.     s.add_task((lambda : 4 / 0), 1)
  742.     sleep(3)
  743.     if not l == [
  744.         'b']:
  745.         raise AssertionError
  746.     f.set()
  747.  
  748.  
  749. def test_closes_if_not_hit():
  750.     
  751.     try:
  752.         da = DummyHandler()
  753.         fa = Event()
  754.         sa = RawServer(fa, 2, 2)
  755.         loop(sa)
  756.         sl(sa, da, beginport + 14)
  757.         sleep(1)
  758.         db = DummyHandler()
  759.         fb = Event()
  760.         sb = RawServer(fb, 100, 100)
  761.         loop(sb)
  762.         sl(sb, db, beginport + 13)
  763.         sleep(0.5)
  764.         sa.start_connection(('127.0.0.1', beginport + 13))
  765.         sleep(1)
  766.         if not da.external_made == []:
  767.             raise AssertionError
  768.         if not da.data_in == []:
  769.             raise AssertionError
  770.         if not da.lost == []:
  771.             raise AssertionError
  772.         if not len(db.external_made) == 1:
  773.             raise AssertionError
  774.         del db.external_made[:]
  775.         if not db.data_in == []:
  776.             raise AssertionError
  777.         if not db.lost == []:
  778.             raise AssertionError
  779.         sleep(3.1)
  780.         if not len(da.lost) == 1:
  781.             raise AssertionError
  782.         if not len(db.lost) == 1:
  783.             raise AssertionError
  784.     finally:
  785.         fa.set()
  786.         fb.set()
  787.  
  788.  
  789.  
  790. def test_does_not_close_if_hit():
  791.     
  792.     try:
  793.         fa = Event()
  794.         fb = Event()
  795.         da = DummyHandler()
  796.         sa = RawServer(fa, 2, 2)
  797.         loop(sa)
  798.         sl(sa, da, beginport + 12)
  799.         sleep(1)
  800.         db = DummyHandler()
  801.         sb = RawServer(fb, 100, 100)
  802.         loop(sb)
  803.         sl(sb, db, beginport + 13)
  804.         sleep(0.5)
  805.         sa.start_connection(('127.0.0.1', beginport + 13))
  806.         sleep(1)
  807.         if not da.external_made == []:
  808.             raise AssertionError
  809.         if not da.data_in == []:
  810.             raise AssertionError
  811.         if not da.lost == []:
  812.             raise AssertionError
  813.         if not len(db.external_made) == 1:
  814.             raise AssertionError
  815.         cb = db.external_made[0]
  816.         del db.external_made[:]
  817.         if not db.data_in == []:
  818.             raise AssertionError
  819.         if not db.lost == []:
  820.             raise AssertionError
  821.         cb.write('bbb')
  822.         sleep(0.5)
  823.         if not da.lost == []:
  824.             raise AssertionError
  825.         if not db.lost == []:
  826.             raise AssertionError
  827.     finally:
  828.         fa.set()
  829.         fb.set()
  830.  
  831.  
  832.